#include "pageview.h"
#include "configmanager.h"
// 页码专用调试宏 - 只输出页码相关信息
#include "pagerendercontext.h"
#include "nextgen_placeholder.h"
#include "unifiedpagerenderer.h"
#include "dpicalculationservice.h"
#include "dpiservice.h"
#include "processingsettings.h"
#include "mainwindow.h"  // Martin Fowler重构：访问全局页数数据源
#include "customfilebrowser.h"
#include "globalpagemanager.h"  // Martin Fowler重构：全局页码管理器
#include "pagedisplaystrategy.h"  // Martin Fowler重构：策略模式
#include "pagedisplaystrategyfactory.h"  // Martin Fowler重构：策略工厂
// QtCore / QtGui / QtWidgets (use non-prefixed includes for IDE compatibility)
#include <QSettings>
#include <QTimer>
#include <QMimeData>
#include <QFileInfo>
#include <QDebug>
#include <QPainter>
#include <QPalette>
#include <QColor>
#include <QMouseEvent>
#include <QResizeEvent>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QDragMoveEvent>
#include <QScrollBar>
#include <QGraphicsPixmapItem>
#include <QBrush>
#include <QApplication>
PageView::PageView(QWidget *parent)
    : QGraphicsView(parent)
    , m_currentPage(-1)
    , m_scrollOffset(0)
    , m_zoomLevel(1.0)
    // 高亮状态由统一渲染器管理，不再需要这些成员变量
    , m_shouldCenterOnUpdate(true)
    , m_isProcessingMode(false)
    , m_progressiveUpdateEnabled(false)
    , m_progressiveUpdateTimer(new QTimer(this))
    , m_unifiedRenderer(nullptr)
    , m_processingSettings(nullptr)  // Martin Fowler重构：依赖注入初始化
{
    m_scene = new QGraphicsScene(this);
    setScene(m_scene);
    setRenderHint(QPainter::Antialiasing);
    setRenderHint(QPainter::SmoothPixmapTransform);
    setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    // 设置主图显示区域背景为温和的浅灰色（Jony Ive风格：微妙层次）
    setStyleSheet("QGraphicsView { background-color: #e8e8e8; }");
    // 使用调色板方法设置背景色
    QPalette palette = this->palette();
    palette.setColor(QPalette::Base, QColor(232, 232, 232));
    setPalette(palette);
    // 设置场景背景色
    m_scene->setBackgroundBrush(QBrush(QColor(232, 232, 232)));
    // 添加这些设置以支持无限制缩放
    setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
    setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing);
    setOptimizationFlag(QGraphicsView::DontSavePainterState);
    setDragMode(QGraphicsView::ScrollHandDrag);  // 允许拖动滚动
    setInteractive(true);  // 允许交互
    // 初始化渐进式更新定时器
    m_progressiveUpdateTimer->setSingleShot(false);
    m_progressiveUpdateTimer->setInterval(1500);  // 每1.5秒检查一次，与缩略图同步
    connect(m_progressiveUpdateTimer, &QTimer::timeout, this, [this]() {
        if (m_progressiveUpdateEnabled && !m_currentFileIdentity.isEmpty()) {
            refreshPagesFromCache(m_currentFileIdentity);
        }
    });

    // 初始化欢迎标签
    m_welcomeLabel = new QLabel(this);
    m_welcomeLabel->setAlignment(Qt::AlignCenter);
    m_welcomeLabel->setWordWrap(true);
    m_welcomeLabel->setVisible(false);

    QString welcomeStyle = R"(
        QLabel {
            color: #8e8e93;
            font-size: 16pt;
            font-weight: 400;
            background-color: transparent;
            padding: 40px;
            text-align: center;
            border: none;
        }
    )";
    m_welcomeLabel->setStyleSheet(welcomeStyle);

    // Martin Fowler重构：初始化默认显示策略
}
void PageView::setPages(const QList<QImage>& pages)
{
    m_pages = pages;
    m_currentPage = m_pages.isEmpty() ? -1 : 0;
    // 初始化懒加载状态
    m_totalPageCount = pages.size();
    m_pageLoaded.clear();
    m_pageLoaded.resize(m_totalPageCount, false);
    // 如果没有页面，显示欢迎信息
    if (m_pages.isEmpty()) {
        m_scene->clear();
        m_scene->setBackgroundBrush(QBrush(QColor(232, 232, 232)));

        // 显示欢迎信息
        if (!m_welcomeMessage.isEmpty() && m_welcomeLabel) {
            m_welcomeLabel->setText(m_welcomeMessage);
            m_welcomeLabel->setVisible(true);

            // 将欢迎标签居中显示
            QRect viewRect = rect();
            m_welcomeLabel->setGeometry(viewRect);
        }
        return;
    } else {
        // 有页面时隐藏欢迎信息
        if (m_welcomeLabel) {
            m_welcomeLabel->setVisible(false);
        }
    }
    // 标记已加载的页面（非占位符页面）
    // 智能检测组合页是否包含占位符
    for (int i = 0; i < pages.size(); ++i) {
        const QImage& img = pages[i];
        // 检查是否为占位符（小尺寸）
        if (NextGenPlaceholder::isPlaceholder(img)) {
            m_pageLoaded[i] = false;
            emit logMessage(QString("PageView::setPages：页面%1是占位符 (%2x%3)")
                            .arg(i).arg(img.width()).arg(img.height()));
        } else {
            // 对于大尺寸页面，检查是否包含占位符内容
            bool containsPlaceholder = checkPageContainsPlaceholder(img, i);
            m_pageLoaded[i] = !containsPlaceholder;
            if (containsPlaceholder) {
                emit logMessage(QString("PageView::setPages：组合页%1包含占位符，标记为需要加载")
                                .arg(i));
            } else {
                emit logMessage(QString("PageView::setPages：组合页%1是真实页面，标记为已加载")
                                .arg(i));
            }
        }
    }
    // 发送日志消息到MainWindow
    emit logMessage(QString("PageView::setPages：设置 %1 个页面，已加载 %2 个")
                    .arg(m_totalPageCount).arg(m_pageLoaded.count(true)));
    // **调试修复**: 强制检查所有页面是否为占位符，并触发重新加载
    QPointer<PageView> safeThis = this;
    QTimer::singleShot(100, this, [safeThis]() {
        if (!safeThis) return;
        emit safeThis->logMessage("PageView::setPages: 开始强制检查占位符并触发重新加载");
        for (int i = 0; i < safeThis->m_pages.size() && i < 10; ++i) { // 检查前10页
            const QImage& img = safeThis->m_pages[i];
            bool isPlaceholder = NextGenPlaceholder::isPlaceholder(img);
            emit safeThis->logMessage(QString("PageView::强制检查页面%1: 尺寸=%2x%3, 是否占位符=%4")
                           .arg(i).arg(img.width()).arg(img.height()).arg(isPlaceholder ? "是" : "否"));
            if (isPlaceholder) {
                emit safeThis->logMessage(QString("PageView::发现占位符页面%1，触发重新加载").arg(i));
                emit safeThis->needMorePages(i, 1);
            }
        }
    });
    // 方案3：智能占位符处理
    if (!m_pages.isEmpty() && hasPlaceholderPages()) {
        emit logMessage("PageView::setPages：检测到占位符页面，启动方案3智能处理");
        // 第一步：立即显示组合后的页面（包含占位符）
        m_scene->clear();
        QPointer<PageView> safeThis = this;
        QTimer::singleShot(200, this, [safeThis]() {
            if (!safeThis) return;
            QSize viewSize = safeThis->viewport()->size();
            if (viewSize.width() < 100 || viewSize.height() < 100) {
                QTimer::singleShot(300, safeThis, [safeThis]() {
                    if (!safeThis) return;
                    QSize finalSize = safeThis->viewport()->size();
                    if (finalSize.width() >= 100 && finalSize.height() >= 100) {
                        safeThis->initializeView();
                    } else {
                        // Martin Fowler重构：避免魔法数字，使用智能缩放
                        safeThis->fitHeight();
                    }
                });
            } else {
                safeThis->initializeView();
            }
        });
        // 第二步：智能加载可见页面
        QTimer::singleShot(500, this, [safeThis]() {
            if (!safeThis) return;
            QPair<int, int> visibleRange = safeThis->getCurrentVisiblePageRange();
            if (visibleRange.first >= 0 && visibleRange.second >= 0) {
                int startIndex = visibleRange.first;
                int count = visibleRange.second - visibleRange.first + 1;
                emit safeThis->logMessage(QString("PageView::setPages：方案3智能加载可见页面，范围=[%1, %2]，数量=%3")
                                .arg(startIndex).arg(visibleRange.second).arg(count));
                emit safeThis->needMorePages(startIndex, count);
            }
        });
        // 第三步：等待加载完成后重新组合
        QTimer::singleShot(1000, this, [safeThis]() {
            if (!safeThis) return;
            emit safeThis->logMessage("PageView::setPages：方案3重新组合已加载页面");
            safeThis->updateScaledImage();
        });
    } else {
        // 没有占位符，使用现有逻辑
        m_scene->clear();
        if (!m_pages.isEmpty()) {
            // 等待主窗口完全显示并布局完成
            QPointer<PageView> safeThis = this;
            QTimer::singleShot(200, this, [safeThis]() {
                if (!safeThis) return;
                QSize viewSize = safeThis->viewport()->size();
                if (viewSize.width() < 100 || viewSize.height() < 100) {
                    // 如果视口大小仍然不合理，继续等待
                    QTimer::singleShot(300, safeThis, [safeThis]() {
                        if (!safeThis) return;
                        QSize finalSize = safeThis->viewport()->size();
                        if (finalSize.width() >= 100 && finalSize.height() >= 100) {
                            safeThis->initializeView();
                        } else {
                            // Martin Fowler重构：避免魔法数字，使用智能缩放
                            safeThis->fitHeight();
                        }
                    });
                } else {
                    safeThis->initializeView();
                }
            });
        }
    }
}
// 新增：携带布局矩形的一次性设置
void PageView::setPages(const QList<QImage>& pages, const QHash<int, QHash<int, QRect>>& layoutRects)
{
    for (auto it = layoutRects.begin(); it != layoutRects.end(); ++it) {
    }
    setPages(pages);
    // 确保完全清除旧数据，保持与setAccurateLayoutRects一致的逻辑
    m_accurateLayoutRects.clear();
    m_accurateLayoutRects = layoutRects;
    m_approxFallbackWarned = false;  // 新布局注入后重置兜底告警
    for (auto it = layoutRects.begin(); it != layoutRects.end(); ++it) {
    }
}
void PageView::initializeView()
{
    // Martin Fowler重构：Replace Conditional with Polymorphism
    // 统一使用智能缩放策略，而不是硬编码fitHeight()
    
    if (ConfigManager::containsNested("view", "zoomLevel")) {
        // 恢复用户保存的缩放级别
        m_zoomLevel = ConfigManager::getZoomLevel();
        
        // 确保缩放级别在合理范围内
        const double minZoom = 0.1;  // 最小10%
        const double maxZoom = 5.0;  // 最大500%
        
        if (m_zoomLevel < minZoom || m_zoomLevel > maxZoom) {
            fitHeight();
        } else {
            updateScaledImage();
        }
    } else {
        // 应用智能默认缩放
        fitHeight();
    }
}
void PageView::setCurrentPage(int index)
{
    if (index >= 0 && index < m_pages.size() && index != m_currentPage) {
        m_currentPage = index;
        m_scrollOffset = 0;
        updateScaledImage();
        emit pageChanged(m_currentPage);
        // 检查是否需要加载更多页面
        QPointer<PageView> safeThis = this;
        QTimer::singleShot(100, this, [safeThis]() {
            if (!safeThis) return;
            safeThis->checkNeedMorePages();
        });
    }
}
// 滚动位置保护方法实现
void PageView::setPagesPreservingScroll(const QList<QImage>& pages)
{
    // 保存当前滚动位置和高亮状态
    QScrollBar* vScrollBar = verticalScrollBar();
    QScrollBar* hScrollBar = horizontalScrollBar();
    int savedVScroll = vScrollBar ? vScrollBar->value() : 0;
    int savedHScroll = hScrollBar ? hScrollBar->value() : 0;
    int savedCurrentPage = m_currentPage;
    double savedZoomLevel = m_zoomLevel;
    // 高亮状态由统一渲染器管理，不需要保存
    // 调用原始的setPages方法
    setPages(pages);
    // 恢复滚动位置和高亮状态
    QPointer<PageView> safeThis = this;
    QTimer::singleShot(100, this, [safeThis, savedVScroll, savedHScroll, savedCurrentPage, savedZoomLevel,
                                   vScrollBar, hScrollBar]() {
        if (!safeThis) return;
        if (vScrollBar) {
            vScrollBar->setValue(savedVScroll);
        }
        if (hScrollBar) {
            hScrollBar->setValue(savedHScroll);
        }
        // 恢复当前页面
        if (savedCurrentPage >= 0 && savedCurrentPage < safeThis->m_pages.size()) {
            safeThis->m_currentPage = savedCurrentPage;
        }
        // 恢复缩放级别
        safeThis->m_zoomLevel = savedZoomLevel;
        safeThis->setTransform(QTransform::fromScale(safeThis->m_zoomLevel, safeThis->m_zoomLevel));
        // 高亮状态由统一渲染器管理，不需要恢复
    });
}
void PageView::updatePagesWithoutReset(const QList<QImage>& pages)
{
    // 只更新页面内容，不重置任何状态
    if (pages.size() != m_pages.size()) {
        setPagesPreservingScroll(pages);
    } else {
        m_pages = pages;
        // 高亮信息已经在setHighlightedThumbnail中设置到渲染器，这里不需要重复设置
        updateScaledImage();
    }
}
void PageView::setProcessingMode(bool processing)
{
    m_isProcessingMode = processing;
}
int PageView::getCurrentVisiblePage() const
{
    if (m_pages.isEmpty()) return -1;
    // 获取视口中心点在场景中的位置
    QPointF centerPoint = mapToScene(viewport()->rect().center());
    // 获取当前页面的高度（考虑缩放）
    double pageHeight = m_pages[m_currentPage].height() + 30; // 30是页面间距
    // 计算中心点在哪个页面区域内
    int visiblePage = m_currentPage;
    if (centerPoint.y() < 0) {
        // 如果中心点在当前页面上方，说明在看上一页
        visiblePage = m_currentPage - 1;
    } else if (centerPoint.y() > pageHeight) {
        // 如果中心点在当前页面下方，说明在看下一页
        visiblePage = m_currentPage + 1;
    }
    // 确保页码在有效范围内
    return qBound(0, visiblePage, m_pages.size() - 1);
}
void PageView::wheelEvent(QWheelEvent *event)
{
    if (m_pages.isEmpty()) return;
    if (event->modifiers() & Qt::ControlModifier) {
        // Ctrl + 滚轮进行缩放
        if (event->angleDelta().y() > 0) {
            zoomIn();
        } else {
            zoomOut();
        }
    } else {
        // 普通滚轮进行平滑滚动
        QScrollBar* vbar = verticalScrollBar();
        if (!vbar) return;
        // 计算滚动步长
        int delta = event->angleDelta().y();
        int scrollValue = vbar->value() - delta;
        // 保原始页码
        int oldPage = m_currentPage;
        // 检查是否需要切换页面
        if (scrollValue >= vbar->maximum() && m_currentPage < m_totalPageCount - 1) {
            // **修复**: 使用总页数而不是m_pages.size()
            if (m_currentPage + 1 < m_pages.size()) {
                // 下一页已在内存中
                m_currentPage++;
                updateScaledImage();
                vbar->setValue(0);
            } else {
                // 下一页不在内存中，请求加载
                emit needMorePages(m_currentPage + 1, 1);
            }
        } else if (scrollValue <= vbar->minimum() && m_currentPage > 0) {
            m_currentPage--;
            updateScaledImage();
            QPointer<PageView> safeThis = this;
            QTimer::singleShot(50, this, [safeThis]() {
                if (!safeThis) return;
                if (auto vbar = safeThis->verticalScrollBar()) {
                    vbar->setValue(vbar->maximum());
                }
            });
        } else {
            // 正常滚动
            vbar->setValue(scrollValue);
        }
        // **优化**: 立即发送页面变化信号，减少滚动延迟
        int visiblePage = getCurrentVisiblePage();
        if (visiblePage != oldPage) {
            emit pageChanged(visiblePage);
        }
        // **关键修复**: 立即触发预加载检查，不等待延迟
        QPointer<PageView> safeThis = this;
        QTimer::singleShot(50, this, [safeThis]() {
            if (!safeThis) return;
            safeThis->checkNeedMorePages();
        });
        // **新增**: 滚动预测预加载机制
        static QTimer* scrollPreloadTimer = nullptr;
        if (!scrollPreloadTimer) {
            scrollPreloadTimer = new QTimer(this);
            scrollPreloadTimer->setSingleShot(true);
            scrollPreloadTimer->setInterval(200);  // 更短的延迟
        }
        // 预测滚动方向并预加载
        scrollPreloadTimer->stop();
        disconnect(scrollPreloadTimer, &QTimer::timeout, nullptr, nullptr);
        connect(scrollPreloadTimer, &QTimer::timeout, this, [safeThis, delta]() {
            if (!safeThis) return;
            // 根据滚动方向预加载更多页面
            int preloadDirection = (delta > 0) ? -1 : 1; // 向上滚动预加载前面，向下滚动预加载后面
            int nextPage = safeThis->m_currentPage + preloadDirection;
            if (nextPage >= 0 && nextPage < safeThis->m_totalPageCount) {
                emit safeThis->needMorePages(nextPage, 3); // 预加载连续3页
            }
        });
        scrollPreloadTimer->start();
    }
    event->accept();
}
void PageView::resizeEvent(QResizeEvent *event)
{
    QGraphicsView::resizeEvent(event);

    // 更新欢迎标签位置
    if (m_welcomeLabel && m_welcomeLabel->isVisible()) {
        QRect viewRect = rect();
        m_welcomeLabel->setGeometry(viewRect);
    }

    // 记录当前视口大小
    QSize viewSize = viewport()->size();
    // 只在初始加载时设置缩放级别，而不是每次resize都设置
    if (!m_pages.isEmpty() && viewSize.width() >= 100 && viewSize.height() >= 100 
        && m_zoomLevel == 1.0) {  // 只在默认缩放级别时调整
        // 计算适应高度的缩放级别
        m_zoomLevel = static_cast<double>(viewSize.height()) / m_pages[m_currentPage].height();
        // 更新视图
        updateScaledImage();
    }
}
QImage PageView::renderCurrentPage(int pageIndex, bool exportMode)
{
    if (pageIndex >= 0 && pageIndex < m_pages.size()) {
        QImage originalImage = m_pages[pageIndex];
        // Martin Fowler重构：Substitute Algorithm - 使用统一渲染器
        if (m_unifiedRenderer) {
            return renderWithUnifiedRenderer(originalImage, pageIndex, exportMode);
        } else {
            // 兜底：返回原始图像（保持向后兼容）
            return originalImage;
        }
    }
    return QImage();
}
void PageView::updateScaledImage()
{
    m_scene->clear();
    if (m_currentPage >= 0 && m_currentPage < m_pages.size()) {
        // 使用UnifiedPageRenderer进行渲染（如果可用）
        QImage currentImage;
        if (m_unifiedRenderer) {
            // 高亮信息已经在setHighlightedThumbnail中设置到渲染器，这里不需要重复设置
            // 设置精确布局矩形
            m_unifiedRenderer->setAccurateLayoutRects(m_accurateLayoutRects);
            // Martin Fowler重构：使用统一数据源解决总页数不一致问题
            // 直接创建PageRenderContext，避免循环依赖
            int currentPage = m_currentPage;  // 0基索引
            int totalPages = getGlobalTotalPageCount();  // 全局总页数（所有文件）
            int globalPage = getCurrentPageNumber();  // 全局页码
            
            
            PageRenderContext currentContext(currentPage, totalPages, 
                                           QSize(viewport()->width(), viewport()->height()),
                                           globalPage);
            currentImage = m_unifiedRenderer->renderForPreviewWithContext(m_pages[m_currentPage], currentContext);
        } else {
            // 回退到原有渲染方法
            currentImage = renderCurrentPage(m_currentPage, false);
        }
        QGraphicsPixmapItem* currentPage = m_scene->addPixmap(QPixmap::fromImage(currentImage));
        currentPage->setPos(0, 0);
        // 如果有下一页，也添加到场景中，使用相同的简化渲染逻辑
        if (m_currentPage < m_pages.size() - 1) {
            QImage nextImage;
            if (m_unifiedRenderer) {
                // 使用统一数据源，但需要手动调整页码
                int nextPage = m_currentPage + 1;  // 0基索引
                int totalPages = getGlobalTotalPageCount();  // 全局总页数（所有文件）
                int nextGlobalPage = getCurrentPageNumber() + 1;  // 下一页的全局页码
                PageRenderContext nextContext(nextPage, totalPages, 
                                            QSize(viewport()->width(), viewport()->height()),
                                            nextGlobalPage);
                nextImage = m_unifiedRenderer->renderForPreviewWithContext(m_pages[m_currentPage + 1], nextContext);
            } else {
                nextImage = renderCurrentPage(m_currentPage + 1, false);
            }
            QGraphicsPixmapItem* nextPage = m_scene->addPixmap(QPixmap::fromImage(nextImage));
            nextPage->setPos(0, currentImage.height() + 30);  // 增加页面间距
        }
        // 如果有上一页，也添加到场景中，使用相同的简化渲染逻辑
        if (m_currentPage > 0) {
            QImage prevImage;
            if (m_unifiedRenderer) {
                // 使用统一数据源，但需要手动调整页码
                int prevPage = m_currentPage - 1;  // 0基索引
                int totalPages = getGlobalTotalPageCount();  // 全局总页数（所有文件）
                int prevGlobalPage = getCurrentPageNumber() - 1;  // 上一页的全局页码
                PageRenderContext prevContext(prevPage, totalPages, 
                                            QSize(viewport()->width(), viewport()->height()),
                                            prevGlobalPage);
                prevImage = m_unifiedRenderer->renderForPreviewWithContext(m_pages[m_currentPage - 1], prevContext);
            } else {
                prevImage = renderCurrentPage(m_currentPage - 1, false);
            }
            QGraphicsPixmapItem* prevPage = m_scene->addPixmap(QPixmap::fromImage(prevImage));
            prevPage->setPos(0, -(prevImage.height() + 30));  // 增加页面间距
        }
        // 设置场景矩形以包含所有页面
        QRectF sceneRect = m_scene->itemsBoundingRect();
        m_scene->setSceneRect(sceneRect);
        // 应用缩放但不改变缩放级别
        setTransform(QTransform::fromScale(m_zoomLevel, m_zoomLevel));
        // 只在需要时才定位到当前页中心
        if (m_shouldCenterOnUpdate) {
            centerOn(currentImage.rect().center());
        }
    }
}
QImage PageView::getPageImage(int index) const
{
    if (index >= 0 && index < m_pages.size()) {
        return m_pages[index];
    }
    return QImage();
}
void PageView::fitWidth()
{
    if (m_pages.isEmpty())
        return;
    resetTransform();
    QSize viewSize = viewport()->size();
    m_zoomLevel = static_cast<double>(viewSize.width()) / m_pages[m_currentPage].width();
    setTransform(QTransform::fromScale(m_zoomLevel, m_zoomLevel));
    saveZoomLevel();
}
void PageView::fitHeight()
{
    if (m_pages.isEmpty()) {
        return;
    }
    resetTransform();
    QSize viewSize = viewport()->size();
    m_zoomLevel = static_cast<double>(viewSize.height()) / m_pages[m_currentPage].height();
    setTransform(QTransform::fromScale(m_zoomLevel, m_zoomLevel));
    saveZoomLevel();
}
void PageView::zoomIn()
{
    m_zoomLevel *= 1.2;
    setTransform(QTransform::fromScale(m_zoomLevel, m_zoomLevel));
    centerOn(m_scene->itemsBoundingRect().center());  // 保持居中
}
void PageView::zoomOut()
{
    m_zoomLevel /= 1.2;
    setTransform(QTransform::fromScale(m_zoomLevel, m_zoomLevel));
    centerOn(m_scene->itemsBoundingRect().center());  // 保持居中
}
void PageView::saveZoomLevel()
{
    // 只在窗口关闭时调用此函数
    
    m_zoomLevel = transform().m11();  // 获取当前缩放级别
    ConfigManager::setZoomLevel(m_zoomLevel);
    ConfigManager::sync();
}
void PageView::restoreZoomLevel()
{
    // 只在初始化时调用此函数
    
    m_zoomLevel = ConfigManager::getZoomLevel();
    
    // 确保缩放级别在合理范围内
    const double minZoom = 0.1;  // 最小10%
    const double maxZoom = 5.0;  // 最大500%
    
    if (m_zoomLevel < minZoom || m_zoomLevel > maxZoom) {
        m_zoomLevel = 1.0;
        ConfigManager::setZoomLevel(m_zoomLevel);
        ConfigManager::sync();
    }
    
    setTransform(QTransform::fromScale(m_zoomLevel, m_zoomLevel));
}
void PageView::retranslateUi()
{
    // 更新所有需要翻譯的文本
    // 例如：工具提、狀態欄信息等
}
PageView::~PageView()
{
    saveZoomLevel();
}

void PageView::dragEnterEvent(QDragEnterEvent* event)
{
    // 不处理文件拖拽，让事件传递到父窗口 (MainWindow)
    if (event->mimeData()->hasUrls()) {
        event->ignore();  // 忽略让父窗口处理
        return;
    }
    // 对于其他类型的拖拽，调用默认处理
    QGraphicsView::dragEnterEvent(event);
}

void PageView::dropEvent(QDropEvent* event)
{
    // 不处理文件拖拽，让事件传递到父窗口 (MainWindow)
    if (event->mimeData()->hasUrls()) {
        event->ignore();  // 忽略让父窗口处理
        return;
    }
    // 对于其他类型的拖拽，调用默认处理
    QGraphicsView::dropEvent(event);
}

void PageView::setHighlightedThumbnail(int thumbnailIndex, int totalThumbnails, int columnMode)
{
    // 简单方案：直接设置到统一渲染器，让渲染器处理高亮绘制
    if (m_unifiedRenderer) {
        m_unifiedRenderer->setHighlightInfo(thumbnailIndex, totalThumbnails, columnMode);
        // 立即更新显示
        updateScaledImage();
    }
    // 延迟居中显示，避免与setCurrentPage冲突
    QPointer<PageView> safeThis = this;
    QTimer::singleShot(100, this, [safeThis, thumbnailIndex, columnMode]() {
        if (!safeThis) return;
        if (safeThis->m_currentPage >= 0 && safeThis->m_currentPage < safeThis->m_pages.size()) {
            QImage currentImage = safeThis->m_pages[safeThis->m_currentPage];
            QRect highlightRect = safeThis->calculatePagePositionInComposite(thumbnailIndex, safeThis->m_currentPage, columnMode, currentImage.width(), currentImage.height());
            if (highlightRect.isValid()) {
                // 计算高亮区域的中心点
                QPointF highlightCenter = highlightRect.center();
                // 将高亮区域居中到视口中心
                safeThis->centerOn(highlightCenter);
            }
        }
    });
}
void PageView::clearHighlight()
{
    // 简单方案：直接清除统一渲染器中的高亮状态
    if (m_unifiedRenderer) {
        m_unifiedRenderer->clearHighlight();
        updateScaledImage();
    }
}
void PageView::drawHighlightRectangles(int pageWidth, int pageHeight)
{
    // 高亮绘制由统一渲染器处理，这个方法不再需要
    Q_UNUSED(pageWidth)
    Q_UNUSED(pageHeight)
}
QRect PageView::calculatePagePositionInComposite(int thumbnailIndex, int currentPage, int columnMode, int pageWidth, int pageHeight)
{
    // 若MainWindow提供了精准矩形，则优先使用
    if (m_currentPage >= 0) {
        auto pageIt = m_accurateLayoutRects.find(m_currentPage);
        if (pageIt != m_accurateLayoutRects.end()) {
            const QHash<int, QRect>& map = *pageIt;
            auto it = map.find(thumbnailIndex);
            if (it != map.end()) {
                // 仅当为非空矩形时使用（空表示该槽没有真实图像）
                if ((*it).isValid() && (*it).width() > 0 && (*it).height() > 0) {
                    return *it;
                } else {
                }
            }
        }
    }
    // 回退方案：使用旧的近似计算逻辑（仅在无精确数据时）
    if (!m_approxFallbackWarned) {
        m_approxFallbackWarned = true;
    }
    // 使用与MainWindow::renderVerticalFlowLayout相同的参数
    int a4Width = 1240;
    int a4Height = 1754;
    int marginTop = 80, marginBottom = 80, marginLeft = 60, marginRight = 60, columnSpacing = 30;
    int availableWidth = a4Width - marginLeft - marginRight;
    int availableHeight = a4Height - marginTop - marginBottom;
    int columns = columnMode;
    int maxPerCol = columnMode;
    int pagesPerResultPage = columns * maxPerCol;
    // 计算相对索引
    int relativeThumbnailIndex = thumbnailIndex - (currentPage * pagesPerResultPage);
    // 检查是否在当前页面范围内
    if (relativeThumbnailIndex < 0 || relativeThumbnailIndex >= pagesPerResultPage) {
        return QRect(); // 不在当前页面内
    }
    // 计算列和行（列优先布局）
    int column = relativeThumbnailIndex / maxPerCol;
    int row = relativeThumbnailIndex % maxPerCol;
    // 计算列宽度
    int columnWidth = (availableWidth - columnSpacing * (columns - 1)) / columns;
    // 计算列的位置
    int colX = marginLeft + column * (columnWidth + columnSpacing);
    // 模拟垂直流布局的Y位置计算
    int currentY = marginTop;
    // 为每一行计算实际高度（这里简化处理，使用平均高度）
    int rowHeight = availableHeight / maxPerCol;
    int actualY = marginTop + row * rowHeight;
    // 计算实际尺寸，确保完全贴合页面边界
    int actualWidth = columnWidth;
    int actualHeight = rowHeight;
    // 最后一列需要补偿剩余宽度
    if (column == columns - 1) {
        actualWidth = pageWidth - colX;
    }
    // 最后一行需要补偿剩余高度
    if (row == maxPerCol - 1) {
        actualHeight = pageHeight - actualY;
    }
    return QRect(colX, actualY, actualWidth, actualHeight);
}
void PageView::setCurrentPageWithHighlight(int pageIndex, int thumbnailIndex, int totalThumbnails, int columnMode)
{
    // 简单方案：直接设置页面和高亮
    if (pageIndex >= 0 && pageIndex < m_pages.size()) {
        // 设置当前页面
        m_currentPage = pageIndex;
        m_scrollOffset = 0;
        // 设置高亮到统一渲染器
        if (m_unifiedRenderer) {
            m_unifiedRenderer->setHighlightInfo(thumbnailIndex, totalThumbnails, columnMode);
        }
        // 更新显示
        updateScaledImage();
        // 计算高亮区域并居中显示
        if (m_currentPage >= 0 && m_currentPage < m_pages.size()) {
            QImage currentImage = m_pages[m_currentPage];
            QRect highlightRect = calculatePagePositionInComposite(thumbnailIndex, m_currentPage, columnMode, currentImage.width(), currentImage.height());
            if (highlightRect.isValid()) {
                // 计算高亮区域的中心点
                QPointF highlightCenter = highlightRect.center();
                // 将高亮区域居中到视口中心
                centerOn(highlightCenter);
            }
        }
        emit pageChanged(m_currentPage);
    }
}
void PageView::mousePressEvent(QMouseEvent *event)
{
    // 取消主图点击选中：不进行任何选中逻辑，仅交由父类处理滚动/拖拽等
    QGraphicsView::mousePressEvent(event);
}
int PageView::calculateThumbnailIndexFromPosition(const QPointF& relativePos, int pageWidth, int pageHeight, int columnMode, int totalThumbnails)
{
    // 注意：这里传入的relativePos已经是相对于当前页面的坐标，不需要再次检查边界
    if (columnMode == 1) {
        // 单栏式：1:1对应
        return m_currentPage;
    } else if (columnMode == 2) {
        // 二栏式：2x2布局，列优先填充
        int columnWidth = pageWidth / 2;
        int columnHeight = pageHeight / 2;
        int column = static_cast<int>(relativePos.x()) / columnWidth;
        int row = static_cast<int>(relativePos.y()) / columnHeight;
        // 二栏式布局：列优先，第0页在左上，第1页在左下，第2页在右上，第3页在右下
        int thumbnailIndex = row * 2 + column;  // 列优先：先填满第一列，再填第二列
        // 加上当前页面包含的起始缩略图索引
        int globalThumbnailIndex = m_currentPage * 4 + thumbnailIndex;
        // 检查是否超出总缩略图数量
        if (globalThumbnailIndex >= totalThumbnails) {
            return -1; // 超出范围
        }
        return globalThumbnailIndex;
    } else if (columnMode == 3) {
        // 三栏式：3x3布局，列优先填充
        int columnWidth = pageWidth / 3;
        int columnHeight = pageHeight / 3;
        int column = static_cast<int>(relativePos.x()) / columnWidth;
        int row = static_cast<int>(relativePos.y()) / columnHeight;
        // 三栏式布局：列优先，第0页在左上，第1页在中上，第2页在右上，第3页在左中，第4页在中中，第5页在右中，第6页在左下，第7页在中下，第8页在右下
        int thumbnailIndex = row * 3 + column;  // 列优先：先填满第一列，再填第二列，最后填第三栏
        // 加上当前页面包含的起始缩略图索引
        int globalThumbnailIndex = m_currentPage * 9 + thumbnailIndex;
        // 检查是否超出总缩略图数量
        if (globalThumbnailIndex >= totalThumbnails) {
            return -1; // 超出范围
        }
        return globalThumbnailIndex;
    }
    return -1;
}
void PageView::setShouldCenterOnUpdate(bool shouldCenter)
{
    m_shouldCenterOnUpdate = shouldCenter;
}
void PageView::updatePageContent(int pageIndex, const QImage& newPageImage)
{
    if (pageIndex >= 0 && pageIndex < m_pages.size()) {
        m_pages[pageIndex] = newPageImage;
        m_pageLoaded[pageIndex] = true;
        // 如果是当前显示的页面，立即更新显示
        if (pageIndex == m_currentPage) {
            updateScaledImage();
        }
    }
}
void PageView::expandTotalPageCount(int newTotalPages)
{
    if (newTotalPages > m_totalPageCount) {
        m_totalPageCount = newTotalPages;
        // 扩展页面加载状态数组
        while (m_pageLoaded.size() < newTotalPages) {
            m_pageLoaded.append(false);
        }
        // 扩展m_pages数组（用占位符填充）
        while (m_pages.size() < newTotalPages) {
            QImage placeholder(800, 1200, QImage::Format_RGB32);
            placeholder.fill(QColor(240, 240, 240));
            m_pages.append(placeholder);
        }
    }
}
void PageView::checkNeedMorePages()
{
    if (m_pages.isEmpty()) return;
    // **新增**: 首先检查是否需要扩展总页数
    // 这里需要从MainWindow获取当前实际的页面数，暂时跳过这个检查
    // 实际的扩展由MainWindow的onNeedMorePages处理
    if (m_pageLoaded.isEmpty()) return;
    // 防重复请求机制
    static QSet<QString> pendingRequests;
    static QTimer* debounceTimer = nullptr;
    if (!debounceTimer) {
        debounceTimer = new QTimer(this);
        debounceTimer->setSingleShot(true);
        debounceTimer->setInterval(150); // **优化**: 减少到150ms防抖，提升响应速度
    }
    // **增强策略**: 检查当前页面前后更多页面是否已加载
    int currentPage = m_currentPage;
    int preloadRange = 5; // **提升**: 预加载前后5页（从2页增加到5页）
    // 减少调试输出频率
    static int debugCounter = 0;
    if (debugCounter % 5 == 0) {  // 每5次调用输出一次
        emit logMessage(QString("PageView懒加载检查：当前页=%1，总页数=%2，页面加载状态大小=%3")
                        .arg(currentPage).arg(m_totalPageCount).arg(m_pageLoaded.size()));
    }
    debugCounter++;
    // 检查需要加载的页面
    QList<int> needLoadPages;
    // 检查后续页面
    for (int i = currentPage; i < qMin(currentPage + preloadRange + 1, m_totalPageCount); ++i) {
        if (i >= 0 && i < m_pageLoaded.size() && !m_pageLoaded[i]) {
            needLoadPages.append(i);
        }
    }
    // 检查前面的页面
    for (int i = qMax(0, currentPage - preloadRange); i < currentPage; ++i) {
        if (i >= 0 && i < m_pageLoaded.size() && !m_pageLoaded[i]) {
            needLoadPages.append(i);
        }
    }
    if (debugCounter % 5 == 0) {
        emit logMessage(QString("PageView懒加载检查：需要加载的页面=%1").arg(needLoadPages.size()));
    }
    // 如果有需要加载的页面，发起请求
    if (!needLoadPages.isEmpty()) {
        // 按顺序加载，优先加载当前页面
        std::sort(needLoadPages.begin(), needLoadPages.end(), [currentPage](int a, int b) {
            return qAbs(a - currentPage) < qAbs(b - currentPage);
        });
        // 每次只请求最接近的几页
        int requestCount = qMin(3, needLoadPages.size());
        int startIndex = needLoadPages.first();
        // 生成请求标识，防止重复请求
        QString requestKey = QString("%1_%2_%3").arg(currentPage).arg(startIndex).arg(requestCount);
        if (!pendingRequests.contains(requestKey)) {
            pendingRequests.insert(requestKey);
            // 使用防抖机制
            if (debounceTimer->isActive()) {
                debounceTimer->stop();
            }
            debounceTimer->disconnect();
            connect(debounceTimer, &QTimer::timeout, [this, startIndex, requestCount, requestKey]() {
                emit logMessage(QString("PageView懒加载检查：发起请求，起始索引=%1，数量=%2")
                                .arg(startIndex).arg(requestCount));
                // 发起请求
                emit needMorePages(startIndex, requestCount);
                // 延迟清理请求标识
                QTimer::singleShot(2000, [requestKey]() {
                    pendingRequests.remove(requestKey);
                });
            });
            debounceTimer->start();
        }
    }
}
bool PageView::checkPageContainsPlaceholder(const QImage& pageImage, int pageIndex)
{
    // 优先读取组合页元数据（由重排时写入），快速准确判断
    const QString metaHasPlaceholder = pageImage.text("LIR_contains_placeholder");
    if (!metaHasPlaceholder.isEmpty()) {
        const bool hasPh = (metaHasPlaceholder == "1");
        emit logMessage(QString("PageView::checkPageContainsPlaceholder：组合页%1，读取元数据标记=%2")
                        .arg(pageIndex).arg(hasPh ? "1" : "0"));
        return hasPh;
    }
    // 方案3增强：检测美观占位符的特征
    int width = pageImage.width();
    int height = pageImage.height();
    // 方法1：检查页面中心区域的像素特征
    int centerX = width / 2;
    int centerY = height / 2;
    int sampleSize = qMin(width, height) / 10;  // 采样区域大小
    int grayCount = 0;
    int uniformCount = 0;
    int totalSamples = 0;
    QList<int> brightnessValues;
    // 在中心区域采样
    for (int x = centerX - sampleSize/2; x < centerX + sampleSize/2; x += 5) {
        for (int y = centerY - sampleSize/2; y < centerY + sampleSize/2; y += 5) {
            if (x >= 0 && x < width && y >= 0 && y < height) {
                QColor pixelColor = pageImage.pixelColor(x, y);
                int r = pixelColor.red();
                int g = pixelColor.green();
                int b = pixelColor.blue();
                // 计算亮度
                int brightness = (r + g + b) / 3;
                brightnessValues.append(brightness);
                // 检查是否为灰色（RGB值接近）
                int maxDiff = qMax(qAbs(r - g), qMax(qAbs(g - b), qAbs(r - b)));
                // 灰色检测：RGB值接近且亮度在占位符范围内
                if (maxDiff < 25 && brightness > 120 && brightness < 180) {
                    grayCount++;
                }
                // 检测是否为均匀颜色（占位符特征）
                if (maxDiff < 15) {
                    uniformCount++;
                }
                totalSamples++;
            }
        }
    }
    if (totalSamples == 0) {
        emit logMessage(QString("PageView::checkPageContainsPlaceholder：组合页%1，无有效采样点")
                        .arg(pageIndex));
        return false;
    }
    // 计算各种比例
    double grayRatio = (double)grayCount / totalSamples;
    double uniformRatio = (double)uniformCount / totalSamples;
    // 计算亮度方差（占位符通常亮度变化较小）
    double brightnessMean = 0;
    for (int brightness : brightnessValues) {
        brightnessMean += brightness;
    }
    brightnessMean /= brightnessValues.size();
    double brightnessVariance = 0;
    for (int brightness : brightnessValues) {
        brightnessVariance += (brightness - brightnessMean) * (brightness - brightnessMean);
    }
    brightnessVariance /= brightnessValues.size();
    // 方案3增强：检测美观占位符的几何图案特征
    bool hasGeometricPatterns = detectGeometricPatterns(pageImage, centerX, centerY);
    // 综合判断：占位符通常具有高灰色比例、高均匀性、低亮度方差，或包含几何图案
    bool containsPlaceholder = (grayRatio > 0.4) || 
                              (uniformRatio > 0.6 && brightnessVariance < 100) ||
                              hasGeometricPatterns;
    emit logMessage(QString("PageView::checkPageContainsPlaceholder：组合页%1，灰色比例=%2，均匀比例=%3，亮度方差=%4，几何图案=%5，包含占位符=%6")
                    .arg(pageIndex)
                    .arg(grayRatio, 0, 'f', 2)
                    .arg(uniformRatio, 0, 'f', 2)
                    .arg(brightnessVariance, 0, 'f', 1)
                    .arg(hasGeometricPatterns ? "是" : "否")
                    .arg(containsPlaceholder ? "是" : "否"));
    return containsPlaceholder;
}
bool PageView::detectGeometricPatterns(const QImage& pageImage, int centerX, int centerY) const
{
    // 检测美观占位符的几何图案特征
    int width = pageImage.width();
    int height = pageImage.height();
    // 检测同心圆图案
    bool hasConcentricCircles = false;
    for (int radius = 60; radius <= 150; radius += 30) {
        if (centerX - radius >= 0 && centerX + radius < width &&
            centerY - radius >= 0 && centerY + radius < height) {
            // 检查圆周上的像素是否具有圆形特征
            int circlePixels = 0;
            int totalCirclePixels = 0;
            for (int angle = 0; angle < 360; angle += 10) {
                double rad = angle * M_PI / 180.0;
                int x = centerX + radius * qCos(rad);
                int y = centerY + radius * qSin(rad);
                if (x >= 0 && x < width && y >= 0 && y < height) {
                    QColor pixel = pageImage.pixelColor(x, y);
                    int brightness = (pixel.red() + pixel.green() + pixel.blue()) / 3;
                    // 检查是否为灰色（占位符特征）
                    if (brightness > 120 && brightness < 180) {
                        circlePixels++;
                    }
                    totalCirclePixels++;
                }
            }
            if (totalCirclePixels > 0 && (double)circlePixels / totalCirclePixels > 0.7) {
                hasConcentricCircles = true;
                break;
            }
        }
    }
    // 检测装饰性线条
    bool hasDecorativeLines = false;
    int linePixels = 0;
    int totalLinePixels = 0;
    // 检查对角线
    for (int i = 0; i < 200; i += 5) {
        int x1 = centerX - 100 + i;
        int y1 = centerY - 100 + i;
        int x2 = centerX + 100 - i;
        int y2 = centerY + 100 - i;
        if (x1 >= 0 && x1 < width && y1 >= 0 && y1 < height) {
            QColor pixel = pageImage.pixelColor(x1, y1);
            int brightness = (pixel.red() + pixel.green() + pixel.blue()) / 3;
            if (brightness > 100 && brightness < 200) {
                linePixels++;
            }
            totalLinePixels++;
        }
        if (x2 >= 0 && x2 < width && y2 >= 0 && y2 < height) {
            QColor pixel = pageImage.pixelColor(x2, y2);
            int brightness = (pixel.red() + pixel.green() + pixel.blue()) / 3;
            if (brightness > 100 && brightness < 200) {
                linePixels++;
            }
            totalLinePixels++;
        }
    }
    if (totalLinePixels > 0 && (double)linePixels / totalLinePixels > 0.6) {
        hasDecorativeLines = true;
    }
    return hasConcentricCircles || hasDecorativeLines;
}
// 方案3：智能占位符处理
QPair<int, int> PageView::getCurrentVisiblePageRange()
{
    if (m_pages.isEmpty()) {
        return QPair<int, int>(-1, -1);
    }
    // 获取当前视口大小和位置
    QRect viewport = this->viewport()->rect();
    QPointF topLeft = mapToScene(viewport.topLeft());
    QPointF bottomRight = mapToScene(viewport.bottomRight());
    // 计算可见页面范围
    int startPage = m_currentPage;
    int endPage = m_currentPage;
    // 根据当前页面高度计算可见范围
    if (m_currentPage >= 0 && m_currentPage < m_pages.size()) {
        double pageHeight = m_pages[m_currentPage].height() + 30; // 30是页面间距
        // 计算视口中心点
        QPointF centerPoint = mapToScene(viewport.center());
        // 计算可见页面范围（包括当前页面前后各1页）
        int bufferPages = 1; // 预加载前后1页
        startPage = qMax(0, m_currentPage - bufferPages);
        endPage = qMin(m_pages.size() - 1, m_currentPage + bufferPages);
        // 如果视口很大，可能需要更多页面
        if (viewport.height() > pageHeight * 1.5) {
            bufferPages = 2; // 增加预加载范围
            startPage = qMax(0, m_currentPage - bufferPages);
            endPage = qMin(m_pages.size() - 1, m_currentPage + bufferPages);
        }
    }
    emit logMessage(QString("PageView::getCurrentVisiblePageRange：当前页=%1，可见范围=[%2, %3]")
                    .arg(m_currentPage).arg(startPage).arg(endPage));
    return QPair<int, int>(startPage, endPage);
}
bool PageView::hasPlaceholderPages()
{
    if (m_pages.isEmpty()) {
        return false;
    }
    // 检查当前可见页面范围内是否有占位符
    QPair<int, int> visibleRange = getCurrentVisiblePageRange();
    if (visibleRange.first < 0 || visibleRange.second < 0) {
        return false;
    }
    for (int i = visibleRange.first; i <= visibleRange.second; ++i) {
        if (i >= 0 && i < m_pages.size()) {
            const QImage& img = m_pages[i];
            // 检查是否为占位符（小尺寸）
            if (NextGenPlaceholder::isPlaceholder(img)) {
                emit logMessage(QString("PageView::hasPlaceholderPages：页面%1是占位符 (%2x%3)")
                                .arg(i).arg(img.width()).arg(img.height()));
                return true;
            }
            // 检查是否包含占位符内容
            if (checkPageContainsPlaceholder(img, i)) {
                emit logMessage(QString("PageView::hasPlaceholderPages：页面%1包含占位符内容")
                                .arg(i));
                return true;
            }
        }
    }
    return false;
}
// 渐进式页面更新功能实现
void PageView::enableProgressivePageUpdate(bool enabled)
{
    m_progressiveUpdateEnabled = enabled;
    if (enabled) {
        m_progressiveUpdateTimer->start();
    } else {
        m_progressiveUpdateTimer->stop();
    }
}
void PageView::refreshPagesFromCache(const QString& fileIdentity)
{
    if (fileIdentity.isEmpty()) {
        return;
    }
    m_currentFileIdentity = fileIdentity;
    // 检查可见页面范围，优先更新可见页面
    QPair<int, int> visibleRange = getCurrentVisiblePageRange();
    bool hasUpdates = false;
    int updatedCount = 0;
    // 优先检查可见页面
    for (int i = visibleRange.first; i <= visibleRange.second && i >= 0 && i < m_pages.size(); ++i) {
        bool isPlaceholder = NextGenPlaceholder::isPlaceholder(m_pages[i]);
        if (isPlaceholder) {
            // 尝试从缓存加载真实页面
            emit needMorePages(i, 1);
            hasUpdates = true;
            updatedCount++;
        }
    }
    // 如果可见页面没有占位符，检查附近页面
    if (!hasUpdates) {
        int currentPage = m_currentPage >= 0 ? m_currentPage : 0;
        int checkStart = qMax(0, currentPage - 2);
        int checkEnd = qMin(m_pages.size() - 1, currentPage + 2);
        for (int i = checkStart; i <= checkEnd; ++i) {
            if (i >= 0 && i < m_pages.size() && NextGenPlaceholder::isPlaceholder(m_pages[i])) {
                emit needMorePages(i, 1);
                hasUpdates = true;
                updatedCount++;
                break; // 一次只更新一个非可见页面
            }
        }
    }
    if (hasUpdates) {
    }
}
void PageView::updateProcessingProgress(int completedPages, int totalPages)
{
    Q_UNUSED(completedPages)
    Q_UNUSED(totalPages)
    // 当文件处理进度更新时，立即尝试刷新页面
    if (m_progressiveUpdateEnabled && !m_currentFileIdentity.isEmpty()) {
        refreshPagesFromCache(m_currentFileIdentity);
    }
}
void PageView::setUnifiedRenderer(UnifiedPageRenderer* renderer)
{
    m_unifiedRenderer = renderer;
}

void PageView::forceUpdatePageNumbers()
{
    // Martin Fowler重构：处理多页显示的页码更新
    // 当PageView显示连续多页时，需要更新所有可见页面的页码
    
    if (m_pages.isEmpty() || m_currentPage < 0 || !m_unifiedRenderer) {
        return;
    }
    
    // 检查场景中是否有多个页面项
    QList<QGraphicsItem*> items = scene()->items();
    QList<QGraphicsPixmapItem*> pageItems;
    for (QGraphicsItem* item : items) {
        if (QGraphicsPixmapItem* pixmapItem = qgraphicsitem_cast<QGraphicsPixmapItem*>(item)) {
            pageItems.append(pixmapItem);
        }
    }
    
    if (pageItems.size() > 1) {
        // 多页显示：需要重新渲染所有可见页面
        // 使用updateScaledImage()来正确处理多页显示
        updateScaledImage();
    } else {
        // 单页显示：只更新当前页面
        // 直接使用updateScaledImage()来更新显示
        updateScaledImage();
    }
}

// ========== 类型安全API实现（V2） ==========

std::optional<PageNumberV2::GlobalPageContext> PageView::getCurrentContext() const
{
    // 使用新的类型安全API
    auto& globalManager = GlobalPageManager::instance();
    
    if (m_currentFileIdentity.isEmpty() || m_pages.isEmpty()) {
        return std::nullopt;
    }
    
    // 使用GlobalPageManager的类型安全API
    auto context = globalManager.getPageContext(
        m_currentFileIdentity,
        PageNumberV2::ArrayIndex(m_currentPage)
    );
    
    if (context.has_value()) {
    } else {
    }
    
    return context;
}

// ========== 旧API实现（兼容层） ==========

int PageView::getCurrentPageNumber() const
{
    // 使用新API实现
    auto context = getCurrentContext();
    if (context.has_value()) {
        return context->currentPageValue();
    }
    
    // 后备方案
    return 1;
}

QImage PageView::renderWithUnifiedRenderer(const QImage& originalImage, int pageIndex, bool exportMode)
{
    if (!m_unifiedRenderer || originalImage.isNull()) {
        return originalImage;
    }
    
    // 设置页面内容到渲染器
    m_unifiedRenderer->setPageContent(originalImage);
    
    // 使用GlobalPageManager计算全局页码（包含起始页码偏移量）
    int globalPage;
    if (!m_currentFileIdentity.isEmpty()) {
        auto& globalManager = GlobalPageManager::instance();
        globalPage = globalManager.convertToGlobalPage(m_currentFileIdentity, pageIndex);
    } else {
        // 备用计算：本地计算 + 起始偏移量
        auto& globalManager = GlobalPageManager::instance();
        int startOffset = globalManager.getPageNumberStartOffset();
        globalPage = m_globalStartPage + pageIndex + startOffset - 1;
    }
    
    // 始终使用全局总页数，不降级到当前文件页数
    // 这确保 {total} 占位符显示的是所有文件的总页数，而不是当前文件的页数
    int globalTotalPages = getGlobalTotalPageCount();
    if (globalTotalPages <= 0) {
        // 如果全局总页数未初始化，从GlobalPageManager重新获取
        auto& globalManager = GlobalPageManager::instance();
        globalTotalPages = globalManager.getTotalGlobalPages();
        // 如果仍然无效，至少使用当前文件的页数作为最小值（但这不应该发生）
        if (globalTotalPages <= 0) {
            qWarning() << "全局总页数未正确初始化，临时使用当前文件页数:" << getTotalPageCount();
            globalTotalPages = qMax(1, getTotalPageCount());
        }
    }
    
    if (exportMode) {
        // 导出模式：按导出DPI计算A4像素尺寸
        const QSize a4ExportSize = DpiSvc.calculateA4PixelSize(DpiService::DpiPurpose::PdfExport);
        QImage exportImage(a4ExportSize, QImage::Format_ARGB32);
        exportImage.fill(Qt::white);
        QPainter painter(&exportImage);
        m_unifiedRenderer->renderToWidget(&painter, exportImage.rect(), globalPage, globalTotalPages);
        painter.end();
        return exportImage;
    } else {
        // 预览模式：按当前面板DPI计算A4像素尺寸
        const QSize a4PreviewSize = DpiSvc.calculateA4PixelSize(DpiService::DpiPurpose::WindowRendering);
        QImage previewImage(a4PreviewSize, QImage::Format_ARGB32);
        previewImage.fill(Qt::white);
        QPainter painter(&previewImage);
        m_unifiedRenderer->renderToWidget(&painter, previewImage.rect(), globalPage, globalTotalPages);
        painter.end();
        return previewImage;
    }
}

bool PageView::setGlobalCurrentPage(int globalPage)
{
    // 将全局页码转换为文件内数组索引
    if (!m_currentFileIdentity.isEmpty()) {
        auto& globalManager = GlobalPageManager::instance();
        int arrayIndex = globalManager.convertToLocalPage(m_currentFileIdentity, globalPage);
        if (arrayIndex >= 0 && arrayIndex < m_pages.size()) {
            setCurrentPage(arrayIndex);
            return true;
        }
    }
    return false;
}

void PageView::setFileGlobalStartPage(int globalStartPage)
{
    m_globalStartPage = globalStartPage;
}

int PageView::getTotalPageCount() const
{
    return m_pages.size();
}

int PageView::getGlobalCurrentPage() const
{
    if (m_currentPage < 0 || m_currentPage >= m_pages.size()) {
        return 0;
    }
    
    // 使用GlobalPageManager计算全局页码
    if (!m_currentFileIdentity.isEmpty()) {
        auto& globalManager = GlobalPageManager::instance();
        return globalManager.convertToGlobalPage(m_currentFileIdentity, m_currentPage);
    }
    
    // 备用计算
    return m_globalStartPage + m_currentPage;
}

int PageView::getGlobalTotalPageCount() const
{
    auto& globalManager = GlobalPageManager::instance();
    int totalPages = globalManager.getTotalGlobalPages();
    
    
    return totalPages;
}

void PageView::setWelcomeMessage(const QString& message)
{
    m_welcomeMessage = message;

    // 如果当前没有页面，立即显示欢迎信息
    if (m_pages.isEmpty() && m_welcomeLabel) {
        m_welcomeLabel->setText(m_welcomeMessage);
        m_welcomeLabel->setVisible(true);

        // 将欢迎标签居中显示
        QRect viewRect = rect();
        m_welcomeLabel->setGeometry(viewRect);
    }
}
